package at.ac.tuwien.ifs.calendit.basis.dao;

import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Types;
import java.util.List;

import javax.sql.DataSource;

import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.springframework.jdbc.core.SqlParameter;
import org.springframework.jdbc.object.MappingSqlQuery;
import org.springframework.jdbc.object.SqlUpdate;
import org.springframework.transaction.PlatformTransactionManager;
import org.springframework.transaction.TransactionStatus;
import org.springframework.transaction.support.TransactionCallback;
import org.springframework.transaction.support.TransactionTemplate;

import at.ac.tuwien.ifs.calendit.dao.IMitarbeiter;
import at.ac.tuwien.ifs.calendit.domain.Mitarbeiter;
import at.ac.tuwien.ifs.calendit.domain.Raum;

/**
* Implementation of the Mitarbeiter Data Access Object for JDBC. This class makes
* heavy use of the Spring Framework's facilities and provides access to the
* data stored in the database aswell as defines how this data is mapped from
* the application objects to the database tables.<br>
* Also see the Bean-Config file 
* ({@value at.ac.tuwien.ifs.bpse.basis.helper.Constants#SPRINGBEANS})
* for configuration.
* 
* @author The SE-Team
* @version 1.0
* @see MitarbeiterDAO
*/
public class JDBCMitarbeiterDAO implements IMitarbeiter {
	
	/**
	* Retrieves the logger for this class.
	*/
	private static Log log = LogFactory.getLog(JDBCMitarbeiterDAO.class);
	
	/**
	* SQL Datasource. In order to work with data from a database, we need to
	* obtain a connection to the database. A Datasource is part of the JDBC
	* specification and can be seen as a generalized connection factory.
	*/
	private DataSource dataSource = null;
	
	/**
	* Transaction Manager. For encapsulating insert and updates in transaction.
	*/
	private PlatformTransactionManager transactionManager = null;
	
	/**
	* SQL Query Strings.
	*/
	private String sql_getAllMitarbeiters = "";
	private String sql_getMitarbeiter = "";
	private String sql_insertMitarbeiter = "";
	private String sql_getInsertId = "";
	private String sql_updateMitarbeiter = "";
	private String sql_deleteMitarbeiter = "";
	private String sql_checkLogin = "";
	private String sql_checkRechte = "";
	private String sql_updatePW = "";
	private String sql_getMitarbeiterById = "";
	private String sql_getMitarbeiterByName = "";
	private String sql_updateMitarbeiterAbteilung = "";
	
	/**
	* Query Objects.
	*/
	private Query_GetMitarbeiter query_getMitarbeiter;
	private Query_InsertMitarbeiter query_insertMitarbeiter;
	private Query_UpdateMitarbeiter query_updateMitarbeiter;
	private Query_DeleteMitarbeiter query_deleteMitarbeiter;
	private Query_GetMitarbeiterID query_getMitarbeiterId;
	private Query_GetAllMitarbeitersOrderMatnr query_getAllMitarbeitersOrderID;
	private Query_GetAllMitarbeitersOrderNachname query_getAllMitarbeitersOrderNachname;
	private Query_CheckLogin query_checkLogin; 
	private Query_CheckRechte query_checkRechte;
	private Query_UpdatePW query_updatePW;
	private Query_GetMitarbeiterById query_getMitarbeiterById;
	private Query_GetMitarbeiterByName query_getMitarbeiterByName;
	private Query_UpdateMitarbeiterAbteilung query_updateMitarbeiterAbteilung;
	
	/** ******************************************************************* */
	/** ******************************************************************* */
	/* INNER CLASSES TO DEFINE SQL STATEMENTS AND MAPPINGS */
	/** ******************************************************************* */
	/** ******************************************************************* */
	
	/**
	* Defines the base class used for all other queries. This is a private
	* inner class, as this is used only in this data access object
	*/
	private class BaseMitarbeitersQuery extends MappingSqlQuery {
		/**
		* The Base query is extended by all other queries
		* 
		* @param ds SQL Datasource
		* @see #dataSource
		* @param sql  The SQL search String
		*/
		public BaseMitarbeitersQuery(DataSource ds, String sql) {
			super(ds, sql);
		}
		
		protected Mitarbeiter mapRow(ResultSet rs, int rowNumber)
		throws SQLException {
			Mitarbeiter mitarbeiter = new Mitarbeiter();
			mitarbeiter.setId(rs.getInt("id"));
 			mitarbeiter.setVname(rs.getString("vname"));
 			mitarbeiter.setNname(rs.getString("nname"));
 			mitarbeiter.setPasswort(rs.getString("passwort"));
 			mitarbeiter.setVorgesetzter(Integer.valueOf(rs.getInt("vorgesetzter")));
 			mitarbeiter.setAbteilung(rs.getString("abteilung"));
 			mitarbeiter.setRechte(rs.getInt("rechte"));
 			mitarbeiter.setKrank(rs.getBoolean("krank"));
			return mitarbeiter;
		}
	}
	
	/**
	* Retrieves all mitarbeiter in the DB ordered by their Matrikel number. This
	* is a private inner class, as this is used only in this data access
	* object.
	*/
	private class Query_GetAllMitarbeitersOrderMatnr extends BaseMitarbeitersQuery {
		/**
		* Fetches all mitarbeiter from table
		* 
		* @param ds SQL Datasource
		*            
		* @see #dataSource
		*/
		public Query_GetAllMitarbeitersOrderMatnr(DataSource ds) {
			super(ds, sql_getAllMitarbeiters + " order by id");
			compile();
		}
	}
	
	/**
	* Retrieves all mitarbeiter in the DB ordered by their last name. This is a
	* private inner class, as this is used only in this data access object.
	*/
	private class Query_GetAllMitarbeitersOrderNachname extends BaseMitarbeitersQuery {
		/**
		* Fetches all mitarbeiter from table.
		* 
		* @param ds  SQL Datasource
		* @see #dataSource
		*/
		public Query_GetAllMitarbeitersOrderNachname(DataSource ds) {
			super(ds, sql_getAllMitarbeiters + " order by nname");
			compile();
		}
	}
	
	/**
	* Retrieves one mitarbeiter from the DB. This is a private inner class, as this
	* is used only in this data access object
	*/
	private class Query_GetMitarbeiter extends BaseMitarbeitersQuery {
		/**
		* Fetches only ONE mitarbeiter from database.
		* 
		* @param ds  SQL Datasource
		* @see #dataSource
		*/
		public Query_GetMitarbeiter(DataSource ds) {
			super(ds, sql_getMitarbeiter);
			super.declareParameter(new SqlParameter("id", Types.INTEGER));
			compile();
		}
	}
	
	/**
	* Adds one mitarbeiter to database. This is a private inner class, as this is
	* used only in this data access object.
	* SqlUpdate is a helper class provided by the Spring-Framework
	*/
	private class Query_InsertMitarbeiter extends SqlUpdate {
		/**
		* Retrieves the ID of the mitarbeiter added to database.
		* 
		* @param ds  SQL Datasource
		* @see #dataSource
		*/
		public Query_InsertMitarbeiter(DataSource ds) {
			setDataSource(ds);
			setSql(sql_insertMitarbeiter);
			declareParameter(new SqlParameter("id", Types.INTEGER));
 			declareParameter(new SqlParameter("vname", Types.VARCHAR));
 			declareParameter(new SqlParameter("nname", Types.VARCHAR));
 			declareParameter(new SqlParameter("passwort", Types.VARCHAR));
 			declareParameter(new SqlParameter("vorgesetzter", Types.INTEGER));
 			declareParameter(new SqlParameter("abteilung", Types.VARCHAR));
 			declareParameter(new SqlParameter("rechte", Types.VARCHAR));
 			declareParameter(new SqlParameter("krank", Types.VARCHAR));
		}
	}
	
	/**
	* Updates one mitarbeiter in the database. This is a private inner class, as
	* this is used only in this data access object.
	* SqlUpdate is a helper class provided by the Spring-Framework
	*/
	private class Query_UpdateMitarbeiter extends SqlUpdate {
		/**
		* Create and initialises the SQL-Query for updating a mitarbeiter.
		* 
		* @param ds  SQL Datasource
		* @see #dataSource
		*/
		public Query_UpdateMitarbeiter(DataSource ds) {
			setDataSource(ds);
			setSql(sql_updateMitarbeiter);
			declareParameter(new SqlParameter("id", Types.INTEGER));
 			declareParameter(new SqlParameter("vname", Types.VARCHAR));
 			declareParameter(new SqlParameter("nname", Types.VARCHAR));
 			declareParameter(new SqlParameter("passwort", Types.VARCHAR));
 			declareParameter(new SqlParameter("vorgesetzter", Types.INTEGER));
 			declareParameter(new SqlParameter("abteilung", Types.VARCHAR));
 			declareParameter(new SqlParameter("rechte", Types.VARCHAR));
 			declareParameter(new SqlParameter("krank", Types.VARCHAR));
		}
	}
	
	/**
	* Deletes one stundent from the database. This is a private inner class, as
	* this is used only in this data access object.
	*/
	private class Query_DeleteMitarbeiter extends SqlUpdate {
		/**
		* Creates and initializes the SQL-Query for deleting a mitarbeiter.
		* 
		* @param ds  SQL Datasource
		* @see #dataSource
		*/
		public Query_DeleteMitarbeiter(DataSource ds) {
			setDataSource(ds);
			setSql(sql_deleteMitarbeiter);
			declareParameter(new SqlParameter("id", Types.INTEGER));
		}
	}
	
	/**
	* Retrieves the ID of the mitarbeiter added to database. This is a private
	* inner class, as this is used only in this data access object.
	*/
	private class Query_GetMitarbeiterID extends MappingSqlQuery {
		/**
		* Retrieves the ID of the mitarbeiter added to database.
		* 
		* @param ds
		*            SQL Datasource
		* @see #dataSource
		*/
		public Query_GetMitarbeiterID(DataSource ds) {
			super(ds, sql_getInsertId);
			compile();
		}
		
		protected Object mapRow(ResultSet rs, int rowNumber)
		throws SQLException {
			// "@p0" is the row name hsqldb creates for the one value returning
			// the ID
			Integer id = new Integer(rs.getInt("@p0"));
			return id;
		}
	}
	
	/**
	* Checks if Login combination of ID & PW from mitarbeiter is
	* correct.
	*/
	private class Query_CheckLogin extends BaseMitarbeitersQuery {
		
		public Query_CheckLogin(DataSource ds){
			super(ds, sql_checkLogin);
			super.declareParameter(new SqlParameter("id", Types.INTEGER));
			compile();
		}
	}
	
	private class Query_CheckRechte extends BaseMitarbeitersQuery{
		
		public Query_CheckRechte(DataSource ds) {
			super(ds, sql_checkRechte);
			super.declareParameter(new SqlParameter("id", Types.INTEGER));
			compile();
		}
		
	}
	
	private class Query_UpdatePW extends SqlUpdate{
		/**
		* Creates and initializes the SQL-Query for updating the PW of a mitarbeiter.
		* 
		* @param ds  SQL Datasource
		* @see #dataSource
		*/
		public Query_UpdatePW(DataSource ds) {
			setDataSource(ds);
			setSql(sql_updatePW);
			declareParameter(new SqlParameter("passwort", Types.VARCHAR));
			declareParameter(new SqlParameter("id", Types.INTEGER));
		}
	}
	
	private class Query_GetMitarbeiterById extends BaseMitarbeitersQuery {
		public Query_GetMitarbeiterById(DataSource ds) {
			super(ds, sql_getMitarbeiterById);
			super.declareParameter(new SqlParameter("id", Types.INTEGER));
			compile();
		}
	}
	
	private class Query_GetMitarbeiterByName extends BaseMitarbeitersQuery {
		public Query_GetMitarbeiterByName(DataSource ds) {
			super(ds, sql_getMitarbeiterByName);
			super.declareParameter(new SqlParameter("vname", Types.VARCHAR));
			super.declareParameter(new SqlParameter("nname", Types.VARCHAR));
			compile();
		}
	}
	
	private class Query_UpdateMitarbeiterAbteilung extends SqlUpdate{
		public Query_UpdateMitarbeiterAbteilung(DataSource ds) {
			setDataSource(ds);
			setSql(sql_updateMitarbeiterAbteilung);
			declareParameter(new SqlParameter("abteilung", Types.VARCHAR));
		}
	}
	

	/** ******************************************************************* */
	/** ******************************************************************* */
	/* C O N S T R U C T O R */
	/** ******************************************************************* */
	/** ******************************************************************* */
	
	public JDBCMitarbeiterDAO() {
		super();
	}
	
	/**
	* The Initialise Method must be called after all bean values are set,
	* particularly the datasource and the transaction manager. This is actually
	* performed by the Spring Framework, which sets first of all, all Java Bean
	* Properties and eventually calls this init method (see bean definition in
	* beans.xml configuration file)
	*/
	public void init() {
		log.info("Initialise MitarbeiterDAO");
		query_getMitarbeiter = new Query_GetMitarbeiter(dataSource);
		query_insertMitarbeiter = new Query_InsertMitarbeiter(dataSource);
		query_getMitarbeiterId = new Query_GetMitarbeiterID(dataSource);
		query_updateMitarbeiter = new Query_UpdateMitarbeiter(dataSource);
		query_deleteMitarbeiter = new Query_DeleteMitarbeiter(dataSource);
		query_getAllMitarbeitersOrderID = new Query_GetAllMitarbeitersOrderMatnr(
			dataSource);
		query_getAllMitarbeitersOrderNachname = new Query_GetAllMitarbeitersOrderNachname(
			dataSource);
		query_checkLogin = new Query_CheckLogin(dataSource);
		query_checkRechte = new Query_CheckRechte(dataSource);
		query_updatePW = new Query_UpdatePW(dataSource);
		query_getMitarbeiterById = new Query_GetMitarbeiterById(dataSource);
		query_getMitarbeiterByName = new Query_GetMitarbeiterByName(dataSource);
		query_updateMitarbeiterAbteilung = new Query_UpdateMitarbeiterAbteilung(dataSource);
	}
	
	/**
	* The Destroy Method is called by the Spring Framework to end the lifecycle
	* of this bean, but <b>only</b> when the bean is created as singleton.
	* Check the bean definition in beans.xml configuration file for details.
	*/
	public void destroy() {
		log.info("Destroy MitarbeiterDAO");
	}
	
	/** ******************************************************************* */
	/** ******************************************************************* */
	/*
	* BEAN SETTERS FOR DEPENDENCY INJECTION
	* 
	* Dependency Injection is a design pattern in which the responsibility for
	* object creation and object linking is removed from the objects themselves
	* and transferred to a factory object. It is a way to achieve loose
	* coupling between objects and results in highly testable objects
	* (controlled unit tests).
	* 
	* Factory Object: (Design Pattern) is an object for creating other objects.
	* Typically a factory has a method for every kind of object it is capable
	* of creating. these methods optionally accept parameters defining how the
	* object is created and then return the created object.
	*/
	/** ******************************************************************* */
	/** ******************************************************************* */
	
	/**
	* Sets the SQL String to get all mitarbeiter.
	* 
	* @param sql_getAllMitarbeiters
	*            SQL Statement as String
	*/
	public void setSql_getAllMitarbeiters(String sql_getAllMitarbeiters) {
		this.sql_getAllMitarbeiters = sql_getAllMitarbeiters;
	}
	
	/**
	* Sets the SQL String to get one mitarbeiter with one SQL parameter.
	* 
	* @param sql_getMitarbeiter
	*            SQL Statement as String
	*/
	public void setSql_getMitarbeiter(String sql_getMitarbeiter) {
		this.sql_getMitarbeiter = sql_getMitarbeiter;
	}
	
	/**
	* Sets the SQL String to insert one mitarbeiter into the database.
	* 
	* @param sql_insertMitarbeiter
	*            SQL Statement as String
	*/
	public void setSql_insertMitarbeiter(String sql_insertMitarbeiter) {
		this.sql_insertMitarbeiter = sql_insertMitarbeiter;
	}
	
	/**
	* Sets the SQL String to retrieve the ID of the last executed SQL
	* Statement.
	* 
	* @param sql_getInsertId
	*            SQL Statement as String
	*/
	public void setSql_getInsertId(String sql_getInsertId) {
		this.sql_getInsertId = sql_getInsertId;
	}
	
	/**
	* Sets the SQL String to update a mitarbeiter.
	* 
	* @param sql_updateMitarbeiter
	*            SQL Statement as String
	*/
	public void setSql_updateMitarbeiter(String sql_updateMitarbeiter) {
		this.sql_updateMitarbeiter = sql_updateMitarbeiter;
	}
	
	/**
	* Sets the SQL String to delete a mitarbeiter.
	* 
	* @param sql_deleteMitarbeiter
	*            SQL Statement as String
	*/
	public void setSql_deleteMitarbeiter(String sql_deleteMitarbeiter) {
		this.sql_deleteMitarbeiter = sql_deleteMitarbeiter;
	}
	
	/**
	* Sets the SQL String to check Login (if combination of ID and PW 
	* is correct)
	* 
	* @param sql_checklogin
	* 			SQL Statement as String
	*/
	
	public void setSql_checkLogin(String sql_checklogin){
		this.sql_checkLogin = sql_checklogin;
	}
	
	
	public void setSql_checkRechte(String sql_checkrechte){
		this.sql_checkRechte = sql_checkrechte;
	}
	
	public void setSql_updatePW(String sql_updatePW){
		this.sql_updatePW = sql_updatePW;
	}
	
	public void setSql_getMitarbeiterById(String sql_getMitarbeiterById){
		this.sql_getMitarbeiterById = sql_getMitarbeiterById;
	}
	
	public void setSql_getMitarbeiterByName(String sql_getMitarbeiterByName){
		this.sql_getMitarbeiterByName = sql_getMitarbeiterByName;
	}
	
	public void setSql_updateMitarbeiterAbteilung(String sql_updateMA){
		this.sql_updateMitarbeiterAbteilung = sql_updateMA;
	}
	/**
	* Sets the Datasource to connect to database.
	* 
	* @param dataSource
	*            SQL Datasource
	* @see #dataSource
	*/
	public void setDataSource(DataSource dataSource) {
		this.dataSource = dataSource;
	}
	
	/**
	* Sets the transaction manager.
	* 
	* @param transactionManager
	*            central interface in Spring's transaction infrastructure
	* @see #transactionManager
	*/
	public void setTransactionManager(
		PlatformTransactionManager transactionManager) {
	this.transactionManager = transactionManager;
		}
		
		/** ******************************************************************* */
		/** ******************************************************************* */
		/*
		* DAO METHODS
		* 
		* A Data Access Object (DAO) is a component which provides a common
		* interface between the application and one or more data storage devices,
		* such as a database or a file. The advantage of using data access objects
		* is that any business object (which contains application or operation
		* specific details) does not require direct knowledge of the final
		* destination for the information it manipulates. As a result, _if_ it is
		* necessary to change where or how the data is stored, these modifications
		* can be made without needing to change the main application.
		*/
		/** ******************************************************************* */
		/** ******************************************************************* */
		
		public Mitarbeiter getById(int id) {
			log.info("Get Mitarbeiter ID = " + id);
			List mitarbeiter = query_getAllMitarbeitersOrderID.execute();
			if (mitarbeiter.size() == 1) {
				Mitarbeiter s = (Mitarbeiter) mitarbeiter.get(0);
				log.debug("Returning Mitarbeiter \"" + s.getVname() + " "
					+ s.getNname() + "\"");
				return s;
			} else {
				log.debug("No Mitarbeiter data");
				return null;
			}
		}
		
		/**
		* Inserts one Mitarbeiter into the database. This method uses a transaction
		* manager for performing two queries in one transaction:
		* <ol>
		* <li> the insert statement is performed adding the dataset to the database
		* (first query)</li>
		* <li> the database then automatically generates a unique ID for this
		* dataset, </li>
		* <li> the second query asks the database <i>which</i> id was used for
		* this particular dataset</li>
		* <li> this ID then is set in the mitarbeiter bean and returned by the function</li>
		* </ol>
		* 
		* @param mitarbeiter
		*            Mitarbeiter object holding data of one mitarbeiter
		* @return unique id generated by database assigned to the newly created
		*         Mitarbeiter
		*/
		public Mitarbeiter add(Mitarbeiter mitarbeiter) {
			log.info("Add Mitarbeiter Name = " + mitarbeiter.getVname() + " "
				+ mitarbeiter.getNname());
			log.debug("Initialise SQL Parameters");
			final Object[] param = new Object[] {null,mitarbeiter.getVname(),
				mitarbeiter.getNname(), mitarbeiter.getPasswort(),
			mitarbeiter.getVorgesetzter(),mitarbeiter.getAbteilung(), mitarbeiter.getRechte(), mitarbeiter.isKrank() };
			log.debug("Initialise Transaction Manager");
			TransactionTemplate tt = new TransactionTemplate(transactionManager);
			Object result = tt.execute(new TransactionCallback() {
					public Object doInTransaction(TransactionStatus status) {
						// The transaction is run from here
						log.debug("Start Transaction");
						query_insertMitarbeiter.update(param);
						
						/*
						* activate the following error line to create an Error which
						* terminates this method. One will see, that the complete
						* transaction is rolled back, hence the insert statement above
						* is not executed, alternatively the second rollback statement
						* can be activated with the same result which in that case is a
						* manual rollback of the transaction
						*/
						
						// if (true) throw new Error("Test Exception");
						// or
						// status.setRollbackOnly();
						/*
						* result from query is a list, actually containing only one row
						* and one column
						*/
						List results = query_getMitarbeiterId.execute();
						Integer id = (Integer) results.get(0);
						log.debug("End Transaction");
						return id;
						/*
						* and the transaction ends here! if no error occurs the
						* transaction is committed by Spring otherwise it is rolled
						* back
						*/
					}
			});
			Integer id = (Integer) result;
			mitarbeiter.setId(id);
			log.info("Return ID from inserted dataset = " + id);
			return (id!=0) ? mitarbeiter : null;
		}
		
		public Mitarbeiter update(Mitarbeiter mitarbeiter) {
			return updateMitarbeiter(mitarbeiter, mitarbeiter.getId());
		}
		
		public Mitarbeiter updateMitarbeiter(Mitarbeiter mitarbeiter, long id) {
			log.info("Update Mitarbeiter, ID = " + mitarbeiter.getId() + " new ID = "
				+ id);
			log.debug("Initialise SQL Parameters");
			final Object[] param = new Object[] {  mitarbeiter.getVname(),
				mitarbeiter.getNname(), mitarbeiter.getPasswort(),
			mitarbeiter.getVorgesetzter(),mitarbeiter.getAbteilung(), mitarbeiter.getRechte(), mitarbeiter.isKrank(), id };
			log.debug("Execute Update");
			if (query_updateMitarbeiter.update(param) == 1) {
				log.debug("Update Successfull");
				return mitarbeiter;
			}
			log.error("Update for Mitarbeiter ID = " + id + " failed.");
			return null;
		}
		
		/**
		* Retrieves all mitarbeiter from the database. <br>
		* <b>Warning:</b> this type of DAO method would not be used in a real-
		* world application because there may be thousands of mitarbeiter in the
		* database and this method would retrieve them all. <br>
		* This is usually not needed: it will generate a huge load on the database
		* and also require enormous amounts of memory. Morover, there is hardly an
		* application conceivable that needs more than a few dozen datasets at any
		* one time.
		*/
		@SuppressWarnings("unchecked")
		public List<Mitarbeiter> getMitarbeiters(String order) {
			log.info("Get all Mitarbeiters order = " + order);
			List<Mitarbeiter> mitarbeiter = null;
			if (order.equals("ID")) {
				mitarbeiter = query_getAllMitarbeitersOrderID.execute();
			} else if (order.equals("Nachname")) {
				mitarbeiter = query_getAllMitarbeitersOrderNachname.execute();
			}
			log.debug("Mitarbeiter List contains " + mitarbeiter.size() + " mitarbeiter");
			return mitarbeiter;
		}
		
		public boolean delete(int id) {
			log.info("Delete Mitarbeiter ID = " + id);
			log.debug("Initialize SQL Parameters");
			final Object[] param = new Object[] { id };
			log.debug("Executing SQL");
			if (query_deleteMitarbeiter.update(param) == 1) {
				log.debug("Deleting successfull");
				return true;
			}
			log.error("Deleting Mitarbeiter ID = " + id + " failed");
			return false;
		}
		
		public String login(int id){
			String pw = "";
			log.info("Retrieving pw from MA with id: "+ id);
			log.info("Executing SQL...");
			List ma = query_checkLogin.execute(id);
			if (ma.size() != 0) {
				Mitarbeiter s = (Mitarbeiter) ma.get(0);
				pw = s.getPasswort(); 
				//get(0) weil id eindeutig, wenn sie existiert, dann ist an 1.stelle
				log.debug("pw retrieving successfull!, pw is: "+pw);
			} else log.debug("this MA does not exist, no pw is set (empty string!)");
			return pw;
		}
		
		public int getRechte(int id){
			int rechte = 0; //initializing, sollte ned 0 sein.
			log.info("Retrieving rechte from MA with id: "+id);
			log.debug("Executing SQL...");
			List<Mitarbeiter> ma = query_checkRechte.execute(id);
			if (ma.size() != 0){
				//get(0) weil id eindeutig, wenn sie existiert, dann ist an 1.stelle
				rechte = ma.get(0).getRechte();
				log.debug("rechte retrieving successfull! rechte: "+rechte);
			} else log.debug("this MA does not exist, therefore rechte is set 0");
			return rechte;
		}
		
		public String getPW(int id){
			String oldPW = "";
			List<Mitarbeiter> ma = query_getMitarbeiter.execute(id);
			if (ma.size() != 0){
				oldPW = ma.get(0).getPasswort();
				log.info("getting old PW: "+oldPW);
			}
			return oldPW;
		} 
		
		public boolean updatePW(String newPW, int id){
			boolean erfolgreich = false;
			final Object[] param = new Object[] { newPW, id };
			
			int update = query_updatePW.update(param);
			if (update ==1){
				log.info("PW erfolgreich upgedatet");
				erfolgreich = true;
			}
			
			return erfolgreich;
		}
		
		public Mitarbeiter getMitarbeiterById(int id){
			List<Mitarbeiter> ma = query_getMitarbeiterById.execute(id);
			if (ma.size() != 0){
				//get(0) weil id eindeutig, wenn sie existiert, dann ist an 1.stelle
				log.debug("getting MA by ID successfull");
				return ma.get(0);
			} else {
				log.debug("this MA does not exist");
				return null;
			}
			
		}
		
		public Mitarbeiter getMitarbeiterByName(String vorname, String nachname){
			Object param[] = new String[] {vorname, nachname};
			List<Mitarbeiter> ma = query_getMitarbeiterByName.execute(param);
			if (ma.size() != 0){
				log.info("getting mitarbeiter by name successfull");
				return ma.get(0);
			} else 
			return null;
		}
		
		public int updateMitarbeiterAbteilung(String abt){
			return query_updateMitarbeiterAbteilung.update(abt);
		}
		
		public boolean deleteAll() {
			// TODO Auto-generated method stub
			return false;
		}
		
		public List<Mitarbeiter> getAll() {
			// TODO Auto-generated method stub
			log.info("Get all Mitarbeiter");
			List<Mitarbeiter> mList = null;
			mList = query_getAllMitarbeitersOrderID.execute();
			log.debug("Number of Mitarbeiters " + mList.size());
			return mList;
		}
		
		
		
}